import 'package:flutter/foundation.dart';
import 'package:get/get.dart';
import 'storage_service.dart';
import 'user_service.dart';

/// 积分权限管理服务
/// 
/// 完全模仿微信小程序的 permission.js 积分权限逻辑
/// 根据用户积分等级判断免费发布活动、加好友等权限
/// 
/// 等级规则（与 level_util.dart 保持一致）：
/// - 0~299积分：刚玩儿 - 付费发布和加好友（10积分/次）
/// - 300~599积分：会玩儿 - 加好友3次/天，免费发布1次/天
/// - 600~1199积分：资深玩家 - 加好友5次/天，免费发布2次/天
/// - 1200~2999积分：大玩家 - 加好友10次/天，免费发布5次/天
/// - 3000+积分：玩神 - 加好友10次/天，免费发布5次/天（专属头像框）
class PointsPermissionService extends GetxService {
  static const String tag = 'PointsPermissionService';
  
  // ==================== 权限控制变量 ====================
  
  /// 是否可以免费加好友
  var canAddFriend = false.obs;
  
  /// 每天免费加好友次数
  var canAddFriendNumber = 0.obs;
  
  /// 是否可以免费发布活动
  var canPublishActivity = false.obs;
  
  /// 每天免费发布活动次数
  var canPublishActivityNumber = 0.obs;
  
  /// 付费发布时每次消耗的积分
  var publishActivityCost = 0.obs;
  
  /// 付费加好友时每次消耗的积分
  var addFriendCost = 0.obs;
  
  // ==================== 本地存储 ====================
  
  static const String _dateKey = 'permission_date';
  static const String _publishCountKey = 'publish_activity_count';
  static const String _addFriendCountKey = 'add_friend_count';
  
  // ==================== 依赖服务 ====================
  
  StorageService? _storageService;
  UserService? _userService;
  
  @override
  void onInit() {
    super.onInit();
    debugPrint('$tag: 积分权限服务初始化开始');
    
    try {
      // 避免重复初始化
      if (_storageService == null) {
        _storageService = Get.find<StorageService>();
      }
      if (_userService == null) {
        _userService = Get.find<UserService>();
      }
      
      // 初始化权限
      initializePermissions();
      
      debugPrint('$tag: 积分权限服务初始化完成');
    } catch (e) {
      debugPrint('$tag: 积分权限服务初始化失败: $e');
    }
  }
  
  // ==================== 权限计算 ====================
  
  /// 🎯 根据用户积分设置权限 - 与 level_util.dart 保持一致
  /// 
  /// [userPoints] 用户积分
  void accordingToUserPointsForPermission(int userPoints) {
    debugPrint('$tag: =============== 权限计算开始 ===============');
    debugPrint('$tag: 💰 当前用户积分: $userPoints');
    
    if (userPoints < 300) {
      // 🎯 0~299积分：刚玩儿 - 可付费发布（每次10积分）、可付费加好友（每次10积分）
      canAddFriend.value = false;
      canAddFriendNumber.value = 0;
      canPublishActivity.value = false;
      canPublishActivityNumber.value = 0;
      publishActivityCost.value = 10;
      addFriendCost.value = 10;
      debugPrint('$tag: 🏷️ 用户等级: 刚玩儿 (0~299积分)');
      debugPrint('$tag: 💰 加好友权限: 可付费加好友（每次消耗10积分）');
      debugPrint('$tag: 💰 发布活动权限: 可付费发布（每次消耗10积分）');
      
    } else if (300 <= userPoints && userPoints < 600) {
      // 🎯 300~599积分：会玩儿 - 加好友3次/天，免费发布1次/天
      canAddFriend.value = true;
      canAddFriendNumber.value = 3;
      canPublishActivity.value = true;
      canPublishActivityNumber.value = 1;
      publishActivityCost.value = 0;  // 免费时不消耗积分
      addFriendCost.value = 3;
      debugPrint('$tag: 🏷️ 用户等级: 会玩儿 (300~599积分)');
      debugPrint('$tag: ✅ 加好友权限: 3次/天（免费），超出后3积分/次');
      debugPrint('$tag: 🎉 发布活动权限: 免费1次/天，超出后每次消耗5积分');
      
    } else if (600 <= userPoints && userPoints < 1200) {
      // 🎯 600~1199积分：资深玩家 - 加好友5次/天，免费发布2次/天
      canAddFriend.value = true;
      canAddFriendNumber.value = 5;
      canPublishActivity.value = true;
      canPublishActivityNumber.value = 2;
      publishActivityCost.value = 0;
      addFriendCost.value = 3;
      debugPrint('$tag: 🏷️ 用户等级: 资深玩家 (600~1199积分)');
      debugPrint('$tag: ✅ 加好友权限: 5次/天（免费），超出后3积分/次');
      debugPrint('$tag: 🎉 发布活动权限: 免费2次/天，超出后每次消耗5积分');
      
    } else if (1200 <= userPoints && userPoints < 3000) {
      // 🎯 1200~2999积分：大玩家 - 加好友10次/天，免费发布5次/天
      canAddFriend.value = true;
      canAddFriendNumber.value = 10;
      canPublishActivity.value = true;
      canPublishActivityNumber.value = 5;
      publishActivityCost.value = 0;
      addFriendCost.value = 3;
      debugPrint('$tag: 🏷️ 用户等级: 大玩家 (1200~2999积分)');
      debugPrint('$tag: ✅ 加好友权限: 10次/天（免费），超出后3积分/次');
      debugPrint('$tag: 🎉 发布活动权限: 免费5次/天，超出后每次消耗5积分');
      
    } else {
      // 🎯 3000+积分：玩神 - 加好友10次/天，免费发布5次/天（专属头像框）
      canAddFriend.value = true;
      canAddFriendNumber.value = 10;
      canPublishActivity.value = true;
      canPublishActivityNumber.value = 5;
      publishActivityCost.value = 0;
      addFriendCost.value = 3;
      debugPrint('$tag: 🏷️ 用户等级: 玩神 (3000+积分)');
      debugPrint('$tag: ✅ 加好友权限: 10次/天（免费），超出后3积分/次');
      debugPrint('$tag: 🎉 发布活动权限: 免费5次/天，超出后每次消耗5积分');
    }
    
    debugPrint('$tag: =============== 权限计算完成 ===============');
  }
  
  /// 🔄 初始化权限系统 - 在应用启动时调用
  void initializePermissions() {
    debugPrint('$tag: 初始化权限系统...');
    
    final userInfo = _userService?.userInfo;
    if (userInfo != null && userInfo.userPoints != null) {
      accordingToUserPointsForPermission(userInfo.userPoints!);
      debugPrint('$tag: 权限初始化完成，用户积分: ${userInfo.userPoints}');
    } else {
      debugPrint('$tag: 用户信息不完整，使用默认权限');
      accordingToUserPointsForPermission(0);  // 默认0积分
    }
  }
  
  /// 💰 更新用户积分并重新计算权限
  /// 
  /// [pointsChange] 积分变化量（可正可负）
  void changeUserPoints(int pointsChange) {
    debugPrint('$tag: =============== 积分变化处理 ===============');
    debugPrint('$tag: 📈 积分变化: ${pointsChange > 0 ? "+$pointsChange" : "$pointsChange"}');
    
    final userInfo = _userService?.userInfo;
    if (userInfo != null && userInfo.userPoints != null) {
      final newPoints = userInfo.userPoints! + pointsChange;
      
      // 更新用户积分
      _userService?.updateUserPoints(newPoints);
      
      // 重新计算权限
      accordingToUserPointsForPermission(newPoints);
      
      debugPrint('$tag: 💰 新积分总数: $newPoints');
      debugPrint('$tag: 🔄 权限已重新计算');
    } else {
      debugPrint('$tag: ⚠️ 用户信息不完整，无法更新积分');
    }
    
    debugPrint('$tag: =============== 积分变化处理完成 ===============');
  }
  
  // ==================== 发布活动权限 ====================
  
  /// 🚀 计算发布活动的free参数
  /// 
  /// 返回: 0=付费发布, 1=免费发布
  /// 抛出: Exception 当积分不足时
  int calculatePublishActivityFree() {
    debugPrint('$tag: =============== 计算发布活动权限 ===============');
    
    final userInfo = _userService?.userInfo;
    final userPoints = userInfo?.userPoints ?? 0;
    
    debugPrint('$tag: 💰 用户当前积分: $userPoints');
    debugPrint('$tag: 🎯 是否有免费权限: ${canPublishActivity.value}');
    debugPrint('$tag: 🎯 每日免费限额: ${canPublishActivityNumber.value}');
    debugPrint('$tag: 💳 付费发布消耗: ${publishActivityCost.value} 积分');
    
    // 第一步：检查是否有免费发布权限
    if (canPublishActivity.value && canPublishActivityNumber.value > 0) {
      final today = _getTodayString();
      final storedDate = _storageService?.getString(_dateKey) ?? '';
      final todayPublishCount = storedDate == today 
          ? (_storageService?.getInt(_publishCountKey) ?? 0) 
          : 0;
      
      debugPrint('$tag: 📅 今日日期: $today');
      debugPrint('$tag: 📊 今日已发布次数: $todayPublishCount');
      
      // 还有免费次数
      if (todayPublishCount < canPublishActivityNumber.value) {
        debugPrint('$tag: ✅ 今日还有免费次数，返回 free = 1 (免费发布)');
        return 1; // 免费
      }
      
      debugPrint('$tag: ⚠️ 今日免费次数已用完');
    } else {
      debugPrint('$tag: ⚠️ 当前等级无免费发布权限');
    }
    
    // 第二步：检查是否有足够积分付费发布
    if (publishActivityCost.value > 0) {
      debugPrint('$tag: 💰 检查积分是否足够付费发布...');
      
      if (userPoints >= publishActivityCost.value) {
        debugPrint('$tag: ✅ 积分充足（$userPoints >= ${publishActivityCost.value}），返回 free = 0 (付费发布)');
        debugPrint('$tag: 📌 将扣除 ${publishActivityCost.value} 积分');
        return 0; // 付费发布
      } else {
        debugPrint('$tag: ❌ 积分不足（$userPoints < ${publishActivityCost.value}）');
        throw Exception('积分不足，需要${publishActivityCost.value}积分才能发布活动');
      }
    }
    
    // 第三步：会玩儿及以上等级，免费次数用完后可付费发布（每次5积分）
    if (canPublishActivity.value && publishActivityCost.value == 0) {
      // 会玩儿及以上等级，免费次数用完后，按5积分/次收费
      const fallbackCost = 5;
      if (userPoints >= fallbackCost) {
        debugPrint('$tag: ✅ 免费次数已用完，使用备选付费模式（$fallbackCost积分/次）');
        return 0; // 付费发布
      } else {
        debugPrint('$tag: ❌ 积分不足（$userPoints < $fallbackCost）');
        throw Exception('免费次数已用完，需要${fallbackCost}积分才能继续发布');
      }
    }
    
    // 异常情况
    debugPrint('$tag: ❌ 未知错误：无法计算发布权限');
    throw Exception('系统错误，请稍后重试');
  }
  
  /// 📈 增加发布活动次数统计
  void incrementPublishActivityCount() {
    final today = _getTodayString();
    final storedDate = _storageService?.getString(_dateKey) ?? '';
    
    if (storedDate != today) {
      // 🔥 新的一天，重置所有计数器
      _storageService?.setString(_dateKey, today);
      _storageService?.setInt(_publishCountKey, 1);
      _storageService?.setInt(_addFriendCountKey, 0);
      debugPrint('$tag: 📅 新的一天开始，所有计数器已重置，发布活动计数=1，加好友计数=0');
    } else {
      // 同一天，增加计数
      final currentCount = _storageService?.getInt(_publishCountKey) ?? 0;
      _storageService?.setInt(_publishCountKey, currentCount + 1);
      debugPrint('$tag: 📈 发布活动计数增加至: ${currentCount + 1}');
    }
  }
  
  /// ✅ 检查用户是否可以发布活动（用于UI预判断）
  /// 
  /// 返回: {canPublish: bool, message: String, cost: int, isFree: bool}
  Map<String, dynamic> checkCanPublishActivity() {
    final userInfo = _userService?.userInfo;
    final userPoints = userInfo?.userPoints ?? 0;
    
    // 检查是否有免费次数
    if (canPublishActivity.value && canPublishActivityNumber.value > 0) {
      final today = _getTodayString();
      final storedDate = _storageService?.getString(_dateKey) ?? '';
      final todayPublishCount = storedDate == today 
          ? (_storageService?.getInt(_publishCountKey) ?? 0) 
          : 0;
      
      if (todayPublishCount < canPublishActivityNumber.value) {
        final remaining = canPublishActivityNumber.value - todayPublishCount;
        return {
          'canPublish': true,
          'message': '今日还可免费发布 $remaining 次',
          'cost': 0,
          'isFree': true,
        };
      }
    }
    
    // 检查付费发布
    final cost = publishActivityCost.value > 0 ? publishActivityCost.value : 5;
    
    if (userPoints >= cost) {
      return {
        'canPublish': true,
        'message': '发布将消耗 $cost 积分',
        'cost': cost,
        'isFree': false,
      };
    } else {
      return {
        'canPublish': false,
        'message': '积分不足，需要 $cost 积分',
        'cost': cost,
        'isFree': false,
      };
    }
  }
  
  // ==================== 加好友权限 ====================
  
  /// 🤝 计算加好友的free参数
  /// 
  /// 返回: 0=付费加好友, 1=免费加好友
  /// 抛出: Exception 当积分不足时
  int calculateAddFriendFree() {
    debugPrint('$tag: =============== 计算加好友权限 ===============');
    
    final userInfo = _userService?.userInfo;
    final userPoints = userInfo?.userPoints ?? 0;
    
    // 🔥 保护机制：如果权限未初始化，先初始化
    if (!canAddFriend.value && canAddFriendNumber.value == 0 && addFriendCost.value == 0) {
      debugPrint('$tag: ⚠️ 检测到权限未初始化，自动初始化权限系统...');
      initializePermissions();
      debugPrint('$tag: ✅ 权限系统已自动初始化');
    }
    
    debugPrint('$tag: 💰 用户当前积分: $userPoints');
    debugPrint('$tag: 🎯 是否有免费权限: ${canAddFriend.value}');
    debugPrint('$tag: 🎯 每日免费限额: ${canAddFriendNumber.value}');
    debugPrint('$tag: 💳 付费加好友消耗: ${addFriendCost.value} 积分');
    
    // 第一步：检查是否有免费加好友权限
    if (canAddFriend.value && canAddFriendNumber.value > 0) {
      final today = _getTodayString();
      final storedDate = _storageService?.getString(_dateKey) ?? '';
      final todayAddFriendCount = storedDate == today 
          ? (_storageService?.getInt(_addFriendCountKey) ?? 0) 
          : 0;
      
      debugPrint('$tag: 📅 今日日期: $today');
      debugPrint('$tag: 📊 今日已加好友次数: $todayAddFriendCount');
      
      // 还有免费次数
      if (todayAddFriendCount < canAddFriendNumber.value) {
        debugPrint('$tag: ✅ 今日还有免费次数，返回 free = 1 (免费加好友)');
        return 1; // 免费
      }
      
      debugPrint('$tag: ⚠️ 今日免费次数已用完');
    } else {
      debugPrint('$tag: ⚠️ 当前等级无免费加好友权限');
    }
    
    // 第二步：检查是否有足够积分付费加好友
    if (addFriendCost.value > 0) {
      debugPrint('$tag: 💰 检查积分是否足够付费加好友...');
      
      if (userPoints >= addFriendCost.value) {
        debugPrint('$tag: ✅ 积分充足（$userPoints >= ${addFriendCost.value}），返回 free = 0 (付费加好友)');
        debugPrint('$tag: 📌 将扣除 ${addFriendCost.value} 积分');
        return 0; // 付费加好友
      } else {
        debugPrint('$tag: ❌ 积分不足（$userPoints < ${addFriendCost.value}）');
        throw Exception('积分不足，需要${addFriendCost.value}积分才能加好友');
      }
    }
    
    // 第三步：会玩儿及以上等级，免费次数用完后可付费加好友（每次3积分）
    if (canAddFriend.value && addFriendCost.value == 0) {
      // 会玩儿及以上等级，免费次数用完后，按3积分/次收费
      const fallbackCost = 3;
      if (userPoints >= fallbackCost) {
        debugPrint('$tag: ✅ 免费次数已用完，使用备选付费模式（$fallbackCost积分/次）');
        return 0; // 付费加好友
      } else {
        debugPrint('$tag: ❌ 积分不足（$userPoints < $fallbackCost）');
        throw Exception('免费次数已用完，需要${fallbackCost}积分才能继续加好友');
      }
    }
    
    // 异常情况
    debugPrint('$tag: ❌ 未知错误：无法计算加好友权限');
    debugPrint('$tag:    当前状态: canAddFriend=${canAddFriend.value}, addFriendCost=${addFriendCost.value}');
    throw Exception('系统错误，请稍后重试');
  }
  
  /// 📈 增加加好友次数统计
  void incrementAddFriendCount() {
    final today = _getTodayString();
    final storedDate = _storageService?.getString(_dateKey) ?? '';
    
    if (storedDate != today) {
      // 🔥 新的一天，重置所有计数器
      _storageService?.setString(_dateKey, today);
      _storageService?.setInt(_addFriendCountKey, 1);
      _storageService?.setInt(_publishCountKey, 0);
      debugPrint('$tag: 📅 新的一天开始，所有计数器已重置，加好友计数=1，发布活动计数=0');
    } else {
      // 同一天，增加计数
      final currentCount = _storageService?.getInt(_addFriendCountKey) ?? 0;
      _storageService?.setInt(_addFriendCountKey, currentCount + 1);
      debugPrint('$tag: 📈 加好友计数增加至: ${currentCount + 1}');
    }
  }
  
  /// ✅ 检查用户是否可以加好友（用于UI预判断）
  /// 
  /// 返回: {canAdd: bool, message: String, cost: int, isFree: bool}
  Map<String, dynamic> checkCanAddFriend() {
    final userInfo = _userService?.userInfo;
    final userPoints = userInfo?.userPoints ?? 0;
    
    // 检查是否有免费次数
    if (canAddFriend.value && canAddFriendNumber.value > 0) {
      final today = _getTodayString();
      final storedDate = _storageService?.getString(_dateKey) ?? '';
      final todayAddFriendCount = storedDate == today 
          ? (_storageService?.getInt(_addFriendCountKey) ?? 0) 
          : 0;
      
      if (todayAddFriendCount < canAddFriendNumber.value) {
        final remaining = canAddFriendNumber.value - todayAddFriendCount;
        return {
          'canAdd': true,
          'message': '今日还可免费加好友 $remaining 次',
          'cost': 0,
          'isFree': true,
        };
      }
    }
    
    // 检查付费加好友
    final cost = addFriendCost.value;
    
    if (userPoints >= cost) {
      return {
        'canAdd': true,
        'message': '加好友将消耗 $cost 积分',
        'cost': cost,
        'isFree': false,
      };
    } else {
      return {
        'canAdd': false,
        'message': '积分不足，需要 $cost 积分',
        'cost': cost,
        'isFree': false,
      };
    }
  }
  
  // ==================== 辅助方法 ====================
  
  /// 📅 获取今日日期字符串 (格式: yyyy-MM-dd)
  String _getTodayString() {
    final now = DateTime.now();
    final year = now.year;
    final month = now.month.toString().padLeft(2, '0');
    final day = now.day.toString().padLeft(2, '0');
    return '$year-$month-$day';
  }
  
  /// 📊 获取今日剩余免费次数信息
  Map<String, int> getTodayRemainingCounts() {
    final today = _getTodayString();
    final storedDate = _storageService?.getString(_dateKey) ?? '';
    
    final todayPublishCount = storedDate == today 
        ? (_storageService?.getInt(_publishCountKey) ?? 0) 
        : 0;
    final todayAddFriendCount = storedDate == today 
        ? (_storageService?.getInt(_addFriendCountKey) ?? 0) 
        : 0;
    
    return {
      'publishActivity': (canPublishActivityNumber.value - todayPublishCount).clamp(0, canPublishActivityNumber.value).toInt(),
      'addFriend': (canAddFriendNumber.value - todayAddFriendCount).clamp(0, canAddFriendNumber.value).toInt(),
    };
  }
  
  /// 🔄 强制刷新权限（在用户积分变化后调用）
  void refreshPermissions() {
    debugPrint('$tag: 刷新权限...');
    initializePermissions();
  }
  
  /// 📊 获取当前发布活动的积分消耗
  int getPublishActivityCost() {
    return publishActivityCost.value;
  }
  
  /// 📊 获取当前加好友的积分消耗
  int getAddFriendCost() {
    return addFriendCost.value;
  }
}

